// 导入现有的枚举类型
import { Component, Vec3, Node, Sprite, UITransform, Color, SpriteFrame, resources, _decorator, SpriteAtlas, Label, Graphics, ProgressBar, input, Input, EventKeyboard, KeyCode, Prefab } from 'cc';
import { EntityType, UnitType, BuildingType, ClientTildeType, PlayerType } from '../../../battle/Enums';
import { ColorsConst, UnitConfig, BuildingConfig, ResourceConfig } from '../../../battle/Const';
import { IndexEntityStatsItemData } from '../../../battle/Model';
import { ResourceLoadManager } from './ResourceLoadManager';
import { InfoTip, InfoTipData } from '../ui/InfoTip';
import { TiledObjectAnimationManager, MoveDirection } from '../effect/TiledObjectAnimationManager';
import { MessageManager, MessageType, MessageUtils } from '../message';
import { TiledObjectData, TiledObjInitConfig, HealthBar } from './TiledObjectData';
import { LOG } from '../../../ConsoleLogCtrl';

const { ccclass, property } = _decorator;


/**
 * 地图块组件类
 * 专注于管理组件和子节点，数据管理由TiledObjectData负责
 */
@ccclass('TiledObject')
export class TiledObject extends Component{
    /** 数据管理器 */
    public data: TiledObjectData;
    /** 提示信息 */
    public tipObj: InfoTip;
    /** ID标签节点 */
    private idLabelNode: Node | null = null;
    /** 动画管理器 */
    public animationManager: TiledObjectAnimationManager | null = null;
    /** 选择边框节点引用 */
    private selectionBorderNode: Node | null = null;
    /** 点击事件回调函数 */
    private clickEventCallback: (() => void) | null = null;
    /** 是否已添加点击事件 */
    private hasClickEvent: boolean = false;
    /** 血条组件 */
    private hpProgressBar: ProgressBar;
    /** 子弹预制体*/
    public bulletPrefab: Prefab;
    /** 消息管理类*/
    private manager: MessageManager;
    /** 高亮实体统计项回调函数 */
    private highlightEntityStatsCallback: ((eventData: IndexEntityStatsItemData) => void) | null = null;

    protected onLoad(): void {
        this.hpProgressBar = this.node.getChildByName('hp').getComponent(ProgressBar);
        this.hpProgressBar.node.active = false;
        ResourceLoadManager.loadPrefab('prefab/bulletPrefab', (err, prefab) => {
            if (err) {
                LOG.error('TiledObject: 加载子弹预制体失败', err);
                return;
            }
            this.bulletPrefab = prefab;
        });
        
    }

    /**
     * 初始化
     * @param config 初始化配置
     */
    public init(config: TiledObjInitConfig): void {
        // 初始化数据管理器
        this.data = new TiledObjectData(config);
        this.name = this.data.name;

        // 初始化消息管理
        this.initMessageManager();
    }

    /**
     * 初始化消息管理
     */
    private initMessageManager(): void {
        // 获取管理器实例
        this.manager = MessageManager.getInstance();
        if(this.data.entityType === EntityType.unit || this.data.entityType === EntityType.building){
            // 订阅单个消息
            this.manager.subscribe(MessageType.GAME_PAUSE,(message) => {
                //TODO关闭动画播放
                if (this.animationManager) {
                    this.animationManager.pauseAllAnimations();
                }
            }, this);

            this.manager.subscribe(MessageType.GAME_RESUME, (message) => {
                //TODO恢复动画播放 或者根据数据重置所有动画状态
                if (this.animationManager) {
                    this.animationManager.resumeAllAnimations();
                }
            }, this);

            this.manager.subscribe(MessageType.GAME_RESET, (message) => {
                //TODO重置所有数据
                //this.clear()
            }, this);
        }
    }

    /**
     * 取消消息订阅
     * 清理该对象的所有消息订阅，防止内存泄漏
     */
    public unsubscribeMessages(): void {
        if (this.manager) {
            // 取消该对象的所有消息订阅
            this.manager.unsubscribeTarget(this);
            LOG.log(`TiledObject ${this.data?.id || 'unknown'} 已取消所有消息订阅`);
        }
    }

    /**
     * 取消特定类型的消息订阅
     * @param messageType 要取消订阅的消息类型
     */
    public unsubscribeMessage(messageType: MessageType): void {
        if (this.manager) {
            // 取消特定类型的消息订阅
            this.manager.unsubscribe(messageType, undefined, this);
            LOG.log(`TiledObject ${this.data?.id || 'unknown'} 已取消消息订阅: ${messageType}`);
        }
    }

    
    /**
     * 更新数据
     * @param config 更新配置
     */
    public updateInfo(config: TiledObjInitConfig): void {
        // 更新数据
        this.data.updateInfo(config);
        this.name = this.data.name;

        // 更新节点层级
        this.node.layer = this.data.position.x + 25;
        // 更新ID标签显示
        this.updateIdLabel();
    }

    /**
     * 更新ID标签显示
     */
    private updateIdLabel(): void {
        if (this.idLabelNode) {
            const label = this.idLabelNode.getComponent(Label);
            if (label) {
                label.string = this.data.id.toString();
            }
        }
    }

    /**
     * 设置ID标签可见性
     * @param visible 是否可见
     */
    public setIdLabelVisible(visible: boolean): void {
        if (this.idLabelNode) {
            this.idLabelNode.active = visible;
        }
    }


    /**
     * 更新位置
     * @param newPosition 新位置
     */
    public updatePosition(newPosition: {x: number; y: number;}): void {
        this.data.updatePosition(newPosition);
    }

    /**
     * 更新血量
     * @param newHealth 新血量值
     */
    public updateHealth(newHealth: number): void {
        const oldHealth = this.data.healthBar.current;
        this.data.updateHealth(newHealth);
        if(this.data.entityType === EntityType.building && this.data.uType == BuildingType.base){
            this.hpProgressBar.node.active = true;
            this.hpProgressBar.progress = this.data.healthBar.current/this.data.healthBar.max;
        }


        if(newHealth < oldHealth){
            // 受伤动画：半透明红色闪烁效果和飘字动画
            const damageValue = oldHealth - newHealth;
            if (this.animationManager) {
                this.animationManager.playDamageAnimation(damageValue);
            }
        }else if(newHealth > oldHealth){
            // 恢复动画：绿色闪烁效果和飘字动画
            const healValue = newHealth - oldHealth;
            if (this.animationManager) {
                this.animationManager.playHealAnimation(healValue);
            }
        }
    }

    /**
     * 设置最大血量
     * @param maxHealth 最大血量值
     */
    public setMaxHealth(maxHealth: number): void {
        this.data.setMaxHealth(maxHealth);
    }

    /**
     * 显示/隐藏血条
     * @param visible 是否显示
     */
    public setHealthBarVisible(visible: boolean): void {
        this.data.setHealthBarVisible(visible);
    }

    /**
     * 获取血量百分比
     * @returns 血量百分比 (0-1)
     */
    public getHealthPercentage(): number {
        return this.data.getHealthPercentage();
    }

    /**
     * 判断是否死亡
     * @returns 是否死亡
     */
    public isDead(): boolean {
        return this.data.isDead();
    }

    /**
     * 判断是否为士兵
     * @returns 是否为士兵
     */
    public isSoldier(): boolean {
        return this.data.isSoldier();
    }

    /**
     * 判断是否为采集单位
     * @returns 是否为采集单位
     */
    public isCollector(): boolean {
        return this.data.isCollector();
    }

    /**
     * 判断是否为治疗兵
     * @returns 是否为治疗兵
     */
    public isDoctor(): boolean {
        return this.data.isDoctor();
    }

    /**
     * 判断是否为弓箭手
     * @returns 是否为弓箭手
     */
    public isArcher(): boolean {
        return this.data.isArcher();
    }

    /**
     * 判断是否为建造兵
     * @returns 是否为建造兵
     */
    public isWorker(): boolean {
        return this.data.isWorker();
    }

    /**
     * 判断是否为基地
     * @returns 是否为基地
     */
    public isBase(): boolean {
        return this.data.isBase();
    }

    /**
     * 判断是否为防御塔
     * @returns 是否为防御塔
     */
    public isTower(): boolean {
        return this.data.isTower();
    }

    /**
     * 转换为JSON对象
     * @returns JSON对象
     */
    public toJSON(): object {
        return this.data.toJSON();
    }

    /**
     * 从JSON对象创建实例
     * @param json JSON对象
     * @returns TiledObject实例
     */
    public static fromJSON(json: any): TiledObjInitConfig {
        const obj:TiledObjInitConfig = {
            id: json.id,
            playerType: json.playerType,
            entityType: json.entityType,
            uType: json.uType,
            position: json.position,
            name: json.name,
            healthBar: json.healthBar,
            clientTildeType: json.clientTildeType,
        };
        return obj;
    }

    /**
     * 将网格坐标转换为世界坐标
     * 地图坐标范围：-400到400（总大小800x800）
     * @param gridX 网格X坐标
     * @param gridY 网格Y坐标
     * @returns 世界坐标（以地图中心为原点，范围-400到400）
     */
    public static gridToWorldPosition(gridX: number, gridY: number): Vec3 {
        // 地图大小为50x50格子，每个格子16x16像素，总大小800x800
        // 坐标范围从-400到400，以地图中心为原点

        // 每个格子的像素大小为16x16
        const tilePixelSize = 16;

        // 计算格子中心点的像素坐标（以左下角为原点）
        const pixelX = gridX * tilePixelSize + tilePixelSize / 2;
        const pixelY = gridY * tilePixelSize + tilePixelSize / 2;

        // 转换为以地图中心为原点的坐标
        // X轴：pixelX - 400（向右为正）
        // Y轴：400 - pixelY（向上为正，需要翻转）
        const worldX = pixelX - 400;
        const worldY = 400 - pixelY;

        return new Vec3(worldX, worldY, 0);
    }
    /**
     * 创建渲染节点
     * @param tileSize 瓦片大小
     * @param playerType 玩家类型
     * @param onClickCallback 点击回调函数
     * @returns 创建的节点
     */
    /**
     * 创建渲染节点
     * @param tileSize 瓦片大小
     * @param playerType 玩家类型
     */
    public createRenderNode(tileSize: number, playerType: PlayerType): void {

        // 添加Sprite组件用于显示图像
        let sprite = this.node.getComponent(Sprite);
        if (!sprite) {
            sprite = this.node.addComponent(Sprite);
        }

        // 添加UITransform组件
        let transform = this.node.getComponent(UITransform);
        transform.setContentSize(tileSize, tileSize);
        if(tileSize != 16){
            transform.setAnchorPoint(0.5, 0.2);
        }

         // 初始化动画组件
        this.initializeAnimation();
        // 计算世界坐标位置
        let worldPos = TiledObject.gridToWorldPosition(this.data.position.x, this.data.position.y);
        this.node.setPosition(worldPos.x, worldPos.y, 0);
       
        // 设置精灵帧
        this.setSpriteFrame(sprite, playerType);
        // 地形类型不创建ID标签和点击事件
        if (this.data.entityType !== EntityType.terrain) {
            // 创建ID标签
            this.createIdLabel(tileSize);
            // 添加点击事件
            this.addClickEvent();
            //创建动画
            if (this.animationManager) {
                this.animationManager.playCreateAnimation();
            }
        }else{
            if (this.data.clientTildeType === ClientTildeType.gold || this.data.clientTildeType === ClientTildeType.energy || this.data.clientTildeType === ClientTildeType.wood || this.data.clientTildeType === ClientTildeType.stone) {
                //LOG.log("TiledObject: 资源点%d发光特效播放 ：",this.data.clientTildeType);
                if (this.animationManager) {
                    this.animationManager.playCollectAnimation();
                }
            }
        }

        if(this.hpProgressBar){
            this.hpProgressBar.node.active = false;
        }
        
        if(this.data.entityType === EntityType.building && this.data.uType == BuildingType.base){
            this.hpProgressBar.node.active = true;
            this.hpProgressBar.progress = 1;
            this.hpProgressBar.node.setPosition(0, tileSize + 2, 0);
        }
        this.data.isRender = true;
    }

    /**
     * 创建ID标签
     * @param tileSize 瓦片大小
     */
    private createIdLabel(tileSize: number): void {
        // 创建ID标签节点
        this.idLabelNode = this.node.getChildByName("id");
        // 添加Label组件
        const label = this.idLabelNode.getComponent(Label);
        label.string = this.data.id.toString();
        label.fontSize = 12;
        label.color = new Color(255, 255, 255, 255); // 白色文字

        // 设置标签位置（在单位/建筑上方，增加偏移量）
        this.idLabelNode.setPosition(0, tileSize / 2 + 12, 0);

        // 默认设置为非激活状态
        this.idLabelNode.active = false;
    }

    /**
     * 设置精灵帧
     * @param sprite Sprite组件
     * @param playerType 玩家类型
     */
    private setSpriteFrame(sprite: Sprite, playerType: PlayerType): void {
        // 根据entityTypeEnum参数明确判断实体类型
        if (this.data.entityType === EntityType.unit) {
            // 单位类型
            this.setUnitSpriteFrame(sprite, playerType);
        } else if (this.data.entityType === EntityType.building) {
            // 建筑类型
            this.setBuildingSpriteFrame(sprite, playerType);
        } else if (this.data.entityType === EntityType.terrain) {
            // 地形类型
            this.setTerrainSpriteFrame(sprite);
        }
    }

    /**
     * 设置单位精灵帧
     * @param sprite Sprite组件
     * @param playerType 玩家类型
     */
    private setUnitSpriteFrame(sprite: Sprite, playerType: PlayerType): void {
        if (!sprite) {
            LOG.warn('TiledObject: Sprite组件不存在，无法设置精灵帧');
            return;
        }

        const spriteFrame = ResourceLoadManager.getUnitSpriteFrame(this.data.uType, playerType);
        if (spriteFrame) {
            sprite.spriteFrame = spriteFrame;
        } else {
            LOG.warn(`TiledObject: 无法获取单位类型 ${this.data.uType} 的精灵帧`);
        }
    }


    /**
     * 设置建筑精灵帧
     * @param sprite 精灵组件
     * @param playerType 玩家类型
     */
    private setBuildingSpriteFrame(sprite: Sprite, playerType: PlayerType): void {
        if (!sprite) {
            LOG.warn('TiledObject: Sprite组件不存在，无法设置精灵帧');
            return;
        }

        // 从配置文件获取建筑精灵帧路径
        const spriteFrame = ResourceLoadManager.getBuildingSpriteFrame(this.data.uType, playerType);
        if (spriteFrame) {
            sprite.spriteFrame = spriteFrame;
        } else {
            LOG.warn(`TiledObject: 无法获取建筑类型 ${this.data.uType} 的精灵帧`);
        }
    }

    /**
     * 设置地形精灵帧
     * @param sprite 精灵组件
     */
    private setTerrainSpriteFrame(sprite: Sprite): void {
        if (!sprite) {
            LOG.warn('TiledObject: Sprite组件不存在，无法设置精灵帧');
            return;
        }

        // 从配置文件获取地形精灵帧
        const spriteFrame = ResourceLoadManager.getTerrainSpriteFrame(this.data.uType);
        if (spriteFrame) {
            sprite.spriteFrame = spriteFrame;
        } else {
            LOG.warn(`TiledObject: 无法获取地形类型 ${this.data.uType} 的精灵帧`);
        }
    }

    /**
     * 更新节点位置
     * @param node 要更新的节点
     * @param newPosition 新位置
     * @param animated 是否使用动画
     */
    public updateNodePosition(node: Node, newPosition: {x: number, y: number}, animated: boolean = false) {
        // 检查节点是否有效
        if (!node || !node.isValid) {
            LOG.warn('TiledObject: 尝试更新无效节点的位置');
            return;
        }

        // 更新内部位置（这会自动处理动画播放/停止）
        //this.updatePosition(newPosition);

        // 计算新的世界坐标
        let newWorldPos = TiledObject.gridToWorldPosition(newPosition.x, newPosition.y);

        if (animated) {
            // 执行动画移动，同时播放移动动画
            this.animateNodeMovement(node, newWorldPos);

        } else {
            // 直接设置位置，使用新的Vec3对象
            const newPos = new Vec3(newWorldPos.x, newWorldPos.y, 0);
            node.setPosition(newPos);
        }
    }


    /**
     * 执行节点移动动画（使用tween实现）
     * @param node 要移动的节点
     * @param targetPos 目标位置
     */
    private animateNodeMovement(node: Node, targetPos: Vec3) {
        // 使用动画管理器执行移动动画
        if (this.animationManager) {
            this.animationManager.animateNodeMovement(node, targetPos, () => {
                // 动画完成回调
                //LOG.log('TiledObject: tween移动动画完成');
            });
        }
    }

    /**
     * 初始化动画管理器
     * 创建TiledObjectAnimationManager实例并进行初始化
     */
    private initializeAnimation(): void {
        try {
            // 创建动画管理器实例
            this.animationManager = new TiledObjectAnimationManager(this.node, this.data.uType, this.data.playerType, this.data.entityType);
            if (this.animationManager) {
                this.animationManager.stopEffect();
            }
        } catch (error) {
            LOG.error('TiledObject: 初始化动画管理器失败:', error);
            this.animationManager = null;
        }
    }

    /**
     * 播放移动动画
     * 根据移动方向播放对应的动画，使用动画名称匹配
     * @param direction 移动方向，如果不提供则播放默认动画
     */
    public playMoveAnimation(direction?: MoveDirection): void {
        if (this.animationManager) {
            this.animationManager.playMoveAnimation(direction);
        }
    }

    /**
     * 停止移动动画
     */
    public stopMoveAnimation(): void {
        if (this.animationManager) {
            this.animationManager.stopMoveAnimation();
        }
    }

    /**
     * 播放攻击动画
     * @param direction 攻击方向，如果不提供则播放默认攻击动画
     * @param targetPos 攻击目标位置，用于弓箭手射箭动画
     */
    public playAttackAnimation(direction?: MoveDirection, targetPos?: {x: number, y: number}): void {
        if (this.animationManager) {
            this.animationManager.playAttackAnimation(direction, targetPos);
        }
    }

     /**
      * 播放死亡动画
      * 播放前移除点击事件，防止死亡过程中被点击
      * @param entityType 实体类型，用于区分单位和建筑的死亡动画，默认使用当前实体类型
      */
    public playDeathAnimation(): void {
        // 移除点击事件
        this.removeClickEvent();

        if (this.animationManager) {
            // 如果没有传入entityType，使用当前实体的类型
            this.animationManager.playDeathAnimation();
        }
    }

    /**
     * 播放采集动画
     * @param resourceValue 采集资源价值
     */
    public playCollectAnimation(resourceValue: number): void{
        if (this.animationManager) {
            this.animationManager.playFloatingTextAnimation("💎+"+resourceValue, Color.YELLOW);
        }
    }

    /**
     * 添加点击事件
     * 为非地形实体添加鼠标点击事件处理
     */
    private addClickEvent(): void {
        if (this.hasClickEvent || this.data.entityType === EntityType.terrain) {
            return;
        }

        // 注册键盘事件监听
        input.on(Input.EventType.KEY_DOWN, this.onKeyDown, this);
        // 创建点击事件回调函数
        this.clickEventCallback = () => {
            let heal: HealthBar = { current: this.data.healthBar.current, max: this.data.healthBar.max, visible: true };

            // 根据实体类型获取配置信息
            let attack = 0;
            let attackRange = 0;
            let typeName = "";
            if (this.data.entityType === EntityType.unit) {
                const config = UnitConfig[this.data.uType as UnitType];
                attack = config?.attack || 0;
                attackRange = config?.attackRange || 0;
                typeName = config?.name || "";
            } else if (this.data.entityType === EntityType.building) {
                const config = BuildingConfig[this.data.uType as BuildingType];
                attack = config?.attack || 0;
                attackRange = config?.attackRange || 0;
                typeName = config?.name || "";
            }

            const info: InfoTipData = {
                tileId: this.data.id,
                healthBar: heal,
                name: this.data.name,
                type: typeName,
                attack: attack,
                position: { x: this.data.position.x, y: this.data.position.y },
                attackRange: attackRange,
                playerId: this.data.playerID,
            };
            this.tipObj.show(info, this);

            // 添加选中效果
            this.showSelectedEffect();

            // 索引到单位统计里的对应EntityStatsItem
            if (!this.isDead()){
                this.highlightEntityStatsItem();
            }
        };
        // 添加点击事件监听
        this.node.on(Node.EventType.MOUSE_UP, this.clickEventCallback, this.node);
        this.hasClickEvent = true;
    }

    /**
     * 键盘按下事件处理
     * @param event 键盘事件
     */
    private onKeyDown(event: EventKeyboard): void {
        if (event.keyCode === KeyCode.KEY_Q) {
            // 切换ID标签显示状态
            this.idLabelNode.active = !this.idLabelNode.active;
        }
    }




    /**
     * 移除点击事件
     * 移除鼠标点击事件监听
     */
    private removeClickEvent(): void {
        if (!this.hasClickEvent || !this.clickEventCallback) {
            return;
        }

        // 移除点击事件监听
        this.node.off(Node.EventType.MOUSE_UP, this.clickEventCallback, this.node);
        this.hasClickEvent = false;
    }

    /**
     * 重新添加点击事件
     * 用于节点重用时恢复点击事件
     */
    public reAddClickEvent(): void {
        if (this.data.entityType === EntityType.terrain) {
            return;
        }
        
        // 先移除旧的点击事件（如果存在）
        this.removeClickEvent();
        // 重新添加点击事件
        this.addClickEvent();
    }


    /**
     * 播放指定名称的动画
     * @param animationName 动画名称
     * @param speed 播放速度，默认为2倍速
     */
    public playAnimation(animationName: string, speed: number = 2.0): void {
        if (this.animationManager) {
            this.animationManager.playAnimation(animationName, speed);
        }
    }

    /**
     * 播放飘字动画
     * @param text 要显示的文字内容
     * @param color 文字颜色，可选，默认为白色
     * @param duration 动画持续时间，可选，默认1.5秒
     * @param floatDistance 飘动距离，可选，默认30像素
     */
    public playFloatingTextAnimation(
        text: string, 
        color?: Color, 
        duration?: number, 
        floatDistance?: number
    ): void {
        if (this.animationManager) {
            const defaultColor = color || new Color(255, 255, 255, 255); // 默认白色
            this.animationManager.playFloatingTextAnimation(text, defaultColor, duration, floatDistance);
        }
    }


    /**
     * 恢复所有动画播放
     * 包括Animation组件动画和Tween动画
     */
    public resumeAllAnimations(): void {
        if (this.animationManager) {
            this.animationManager.resumeAllAnimations();
        }
    }



    /**
     * 显示选中效果
     * 为当前对象添加视觉上的选中效果
     */
    public showSelectedEffect(): void {
        // 获取当前节点的Sprite组件
        const sprite = this.node.getComponent(Sprite);
        if (!sprite) return;

        // 添加边框效果（可以通过创建一个子节点实现）
        let borderNode = this.node.getChildByName('SelectionBorder');

        if (!borderNode) {
            // 创建新的边框节点
            borderNode = new Node('SelectionBorder');
            const graphics = borderNode.addComponent(Graphics);

            // 设置边框大小（比父节点稍大）
            const transform = borderNode.addComponent(UITransform);
            const parentTransform = this.node.getComponent(UITransform);
            if (parentTransform) {
                const borderWidth = parentTransform.width + 5;
                const borderHeight = parentTransform.height + 5;
                transform.setContentSize(borderWidth, borderHeight);

                // 绘制边框矩形
                graphics.lineWidth = 2;
                graphics.strokeColor = new Color(255, 255, 0, 255); // 黄色边框
                graphics.rect(-borderWidth/2, -borderHeight/2+4, borderWidth, borderHeight);
                graphics.stroke();
            }

            // 添加到当前节点
            this.node.addChild(borderNode);

            // 确保边框在最上层显示
            borderNode.setSiblingIndex(-1);
        }

        // 保存边框节点引用
        this.selectionBorderNode = borderNode;

        // 显示边框
        borderNode.active = true;
    }

    /**
     * 隐藏选择边框
     */
    public hideSelectionBorder(): void {
        if (this.selectionBorderNode && this.selectionBorderNode.isValid) {
            this.selectionBorderNode.active = false;
        }
    }

    /**
     * 设置高亮实体统计项的回调函数
     * @param callback 高亮回调函数
     */
    public setHighlightEntityStatsCallback(callback: (eventData: IndexEntityStatsItemData) => void): void {
        this.highlightEntityStatsCallback = callback;
    }

    /**
     * 高亮显示对应的EntityStatsItem
     * 通过MapRenderer中的UIManager显示单位统计面板，并调用EntityStatsPanel的高亮方法
     */
    /**
     * 高亮实体统计项
     */
    public highlightEntityStatsItem(): void {
        // 准备实体数据
        const eventData: IndexEntityStatsItemData = {
            entityId: this.data.id,
            playerID: this.data.playerID,
            entityType: this.data.entityType,
            playerType: this.data.playerType
        };

        // 使用回调函数处理高亮逻辑
        if (this.highlightEntityStatsCallback) {
            this.highlightEntityStatsCallback(eventData);
        }
        this.manager.sendMessage(MessageType.HIGHLIGHT_ENTITY_STATS_ITEM, eventData);
    }

    /**
     * 组件销毁时的清理工作
     * 停止所有动画并清理资源
     */
    protected onDestroy(): void {
        // 清理消息订阅，防止内存泄漏
        this.unsubscribeMessages();

        // 清理点击事件
        this.removeClickEvent();
        this.clickEventCallback = null;
        this.highlightEntityStatsCallback = null;

        // 清理动画管理器 - 增强null检查
        if (this.animationManager && typeof this.animationManager.destroy === 'function') {
            try {
                this.animationManager.destroy();
            } catch (error) {
                LOG.warn('TiledObject: 销毁动画管理器时出错:', error);
            } finally {
                this.animationManager = null;
            }
        }
        // 清理提示对象引用
        this.tipObj = null;
        // 清理选择边框节点
        if (this.selectionBorderNode && this.selectionBorderNode.isValid) {
            this.selectionBorderNode.destroy();
            this.selectionBorderNode = null;
        }
        // 清理数据引用
        this.data = null;
    }


    /**
     * 图片颜色设置为白色
    */
    public setSpriteColorWhite(): void {
        if (this.animationManager) {
            this.animationManager.setSpriteColorWhite();
        }
    }

    /**
     * 清理函数清理数据跟动画
    */
    public clear(): void {
        //清理消息订阅
        this.unsubscribeMessages();
        //清理图片显示
        // this.setSpriteColorWhite();
        // this.animationManager.clear();
        // this.data.clear();
        // this.highlightEntityStatsCallback = null;
    }

}